<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        //  1、如何判断数组的类型
        //  Array.isArray() >>> true
        //  instantceof >>> true

        //  var arr = [];
        //  Array.isArray(arr);
        //  arr instanceof Array;

        //  2、如何遍历一个数组
        // var arr = [1, 2, 3];
        // for (var i = 0; i < arr.length; i++) {
        //     console.log(arr[i]);
        // }

        //  3、移除数组 [1, 2, 3, 4, 2] 中所有的 2，不要直接修改数组，结果返回新的数组
        // var arr = [1, 2, 3, 4, 2];
        // var newArr = [];

        // for (var i = 0; i < arr.length; i++) {
        //     if (arr[i] !== 2) {
        //         newArr.push(arr[i]);
        //     }
        // }

        // console.log(newArr);


        //  4、求出该数组中的最大值和最小值 [96, 97, 76, 87, 87, 90, 91, 99, 78, 56];
        // var arr = [96, 97, 76, 87, 87, 90, 91, 99, 78, 56];
        // var max = arr[0];
        // var min = arr[0];

        // for (var i = 0; i < arr.length; i++) {
        //     // 判断 max 是不是最大值，如果不是，代表当前数组项是最大值，将当前数组项赋值给 max
        //     if (max < arr[i]) {
        //         max = arr[i];
        //     }

        //     // 判断 min 是不是最小值，如果不是，代表当前项是最小值，将该项赋值给 min
        //     if (min > arr[i]) {
        //         min = arr[i]
        //     }
        // }

        // console.log(max, min);


        //  5、移除数组中所有为“无效”的元素，直接在原数组上进行操作，不能引入新数组 ["有效", "无效", "有效", "无效", "无效", "有效"]
        // var arr = ["有效", "无效", "有效", "无效", "无效", "有效"];

        // for (var i = 0; i < arr.length; i++) {
        //     // 当当前元素是 “无效” 时，删除当前项
        //     if (arr[i] === '无效') {
        //         arr.splice(i, 1);
        //         i--;
        //     }
        // }

        // console.log(arr);

        //  6、定义一个函数，能在数组 [1, 2, 3, 4, 2] 的 "2" 后面添加元素 "Melon"。不要直接修改数组 arr，结果返回新的数组
        // function pushMelonToArr(array) {
        //     var emptyArr = [];

        //     for (var i = 0; i < array.length; i++) {
        //         // 如果当前值是 “2”，应该推入 "2", "Melon"，否则直接推当前数组项
        //         if (array[i] == 2) {
        //             emptyArr.push(2, "Melon");
        //         } else {
        //             emptyArr.push(array[i]);
        //         }
        //     }

        //     return emptyArr;
        // }

        // console.log(pushMelonToArr([1, 2, 3, 4, 2]));
        // console.log(pushMelonToArr([32, 232, 1, 5, 2, 2, 5]));


        // // 如果要求直接修改原数组
        // function pushMelonToArr(array) {
        //     for (var i = 0; i < array.length; i++) {
        //         if (array[i] == 2) {
        //             array.splice(i + 1, 0, "Melon");
        //             // 这里的 i++ 可以不写，有没有它只是决定接下来 "Melon" 这个元素需不需要进行遍历
        //             i++;
        //         }
        //     }
        //     return array;
        // }

        // console.log(pushMelonToArr([1, 2, 3, 4, 2]));

        //  7、统计数组 [1, 2, 3, 4, 2, 3, 5, 2] 中 2 出现的次数
        // var arr = [1, 2, 3, 4, 2, 3, 5, 2];
        // var count = 0;

        // for (var i = 0; i < arr.length; i++) {
        //     if (arr[i] == 2) {
        //         count++;
        //     }
        // }

        // console.log(count);

        // //  定义一个函数，该函数接收两个参数：数组、要查询次数的值，返回对应值查询的次数
        // function checkCount(array, value) {
        //     var count = 0;

        //     for (var i = 0; i < array.length; i++) {
        //         if (array[i] == value) {
        //             count++;
        //         }
        //     }

        //     return value + '出现的次数为' + count;
        // }

        // console.log(checkCount([1, 3, 5, 7, 9], 2));
        // console.log(checkCount([1, 3, 5, 7, 9], 3));
        // console.log(checkCount([1, 1, 2, 3, 4, 4, 5, 5, 6, 7], 4));


        //  8、找出数组 [1, 2, 3, "melon", 4, "melon", 2, 4, "melon"] 中重复出现过的元素，并用数组将重复元素装起来输出。输出结果为：[2, "melon", 4]
        // var arr = [1, 2, 3, "melon", 4, "melon", 2, 4, "melon"];
        // var newArr = [];


        // //  如果不考虑输出结果的顺序，只需要记录哪个元素发生重复
        // for (var i = 0; i < arr.length; i++) {
        //     // 如果当前元素是个重复元素，并且 newArr 里不存在该元素
        //     if (arr.indexOf(arr[i]) != i && !newArr.includes(arr[i])) {
        //         newArr.push(arr[i]);
        //     }
        // }


        // //  如果要保证重复元素的输出顺序，则要通过 lastIndexOf 判断
        // for (var i = 0; i < arr.length; i++) {
        //     // indexOf 返回从左往右查找到的第一个匹配的元素的下标
        //     // lastIndexOf 返回从右往左查找到的第一个匹配的元素的下标
        //     if (i !== arr.lastIndexOf(arr[i]) && !newArr.includes(arr[i])) {
        //         console.log('下标为' + i + '的值是' + arr[i], '它是一个重复元素');
        //         newArr.push(arr[i])
        //     }
        // }


        // console.log(newArr);


        //  9、设计一个函数，该函数接收一个数组，并能返回一个被倒序的数组。举例：传入 [1,5,3] 返回 [3,5,1]
        // function reverse(arr) {
        //     var newArr = [];

        //     //  倒序 for 循环，从数组的最后一项开始往前遍历
        //     for (var i = arr.length - 1; i >= 0; i--) {
        //         newArr.push(arr[i])
        //     }

        //     return newArr;
        // }

        // console.log(reverse([3, 5, 1, 8, 7]));


        //  10、算法题：设计一个函数，函数接收一个数组，能够将数组内的值从小到大排序，并返回新数组
        //  冒泡排序  [3, 5, 1, 8, 7] >>> [1, 3, 5, 7, 8]
        //  * 从第一个元素开始，比较每两个相邻元素的大小，如果前者大，就交换位置
        //  * 每次遍历结束，都能够找到该次遍历过的元素中的最大值
        //  * 如果还有数没有遍历完，那重复第一个步骤

        function bubbleSort(arr) {
            var length = arr.length - 1;

            // 外层的 for 循环，要找第几大的值
            for (var i = 0; i < length; i++) {
                // 内层的 for 循环，用来对数组中剩余的值进行大小比较
                for (var j = 0; j < length - i; j++) {
                    if (arr[j] > arr[j + 1]) {
                        var temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }

            return arr;
        }

        // 快排

        console.log(bubbleSort([3, 5, 1, 8, 7]));
        console.log(bubbleSort([89, 23, 55, 12, 98, 33]));

        // 第一次，第一个数值，和剩下的四个数值进行比较，得到一个最大值放在倒数第一位
        // [3, 1, 5, 7, 8]
        // 第二次，第二个数值，和剩下的三个数值进行比较，得到一个第二大的值放右侧
        // [3, 1, 5, 7, 8]
        // 第三次，第三个数值，和剩下的两个数值进行比较，得到一个第三大的值放右侧
        // [1, 3, 5, 7, 8]
    </script>
</body>

</html>